import axios from 'axios'
import qs from 'qs'
import { message, notification } from 'ant-design-vue'
import Loading from "@/components/LoadView/index"
import { noTokenApiArray } from '@/config'

//http request 拦截器--start
const isIE9 = () => {
    if (
        navigator.appName == "Microsoft Internet Explorer" &&
        parseInt(
            navigator.appVersion
                .split(";")[1]
                .replace(/[ ]/g, "")
                .replace("MSIE", "")
        ) <= 9
    ) {
        return true;
    }
    return false;
}
const handleData = function (obj) {
    const arr = []
    for (let key in obj) {
        // 核心，要对key和val进行encodeURIComponent编码，不能直接传给后台，不如会报错。 我踩的坑就在这里，没有进行编码就往后传了，就出现了文章开头的问题。
        // 可以用qs.js这个库，来完成这一步的操作。
        // 这个参数的处理，是这个类型请求的核心。在这种数据格式要求下，后端对数据的接收处理，类似于url上的query参数。
        arr.push(`${encodeURIComponent(key)}=${encodeURIComponent(obj[key])}`)
    }
    return arr.join('&')
}

const isJSON =(data)=> {

    if(!(typeof data === 'string' && data.slice(0,1) =='{')){
        return false;
    }
    try {
        let aa = JSON.parse(data);
        return aa;
    } catch (e) {
        return false;
    }
}

// process.env.NODE_ENV === 'development' ?'/api' :'/api', //基础地址
// axios.defaults.baseURL = '/api';
axios.defaults.baseURL = '';
axios.defaults.timeout = 60000;

let loadingNum = 0;
axios.interceptors.request.use(
    config => {
        // console.log(config,'request config',config.requestType)
        /*
        自定义配置说明 :
        requestType：formData/udm/默认     请求类型
        isGetFile: true/false   是否为请求文件，不带Authorization
        */

        // console.log(config.url,'config.requestType',config);
        switch (config.requestType) {
        case 'formData':
            // config.headers['Content-Type'] = 'application/x-www-form-urlencoded'
            config.headers['Content-Type'] = 'multipart/form-data'
            // config.data = qs.stringify(config.data)
            break;
        case 'udm':
            config.headers['Content-Type'] = 'application/x-www-form-urlencoded'
            break;
        default:
            config.headers['Content-Type'] = 'application/json'
            config.headers['x-requested-with'] = 'XMLHttpRequest'
            break;
        }
        // config.headers['channel'] = '1'   //1-pc 2-app，

        config.headers.headeruser = '{"userId":"1", "userName":"test001", "userType":"S"}'
        let token = localStorage.getItem('token');
        // console.log(token,'token',config.url);
        if (token) {
            // if (!config.isGetFile) {
                // config.headers.Authorization = `${token}`;
            config.headers.accessToken = `${token}`;
            // }
        }
        if (config.loading) {
            if (loadingNum == 0) { Loading.show(); }
            loadingNum++;
        }
        return config
    },
    error => {
        return Promise.reject(error);
    }
);

let noToken = true
//http response 拦截器
axios.interceptors.response.use(
    response => {
        if (response?.config?.loading) {
            loadingNum--;
        }
        // console.log(loadingNum)
        if (loadingNum < 1) {
            loadingNum = 0;
            setTimeout(() => {
                Loading.hide();
            })
        }
        //判断是否有是ie9
        if (isIE9()) {
            //特殊处理response
            // if (response.status =='000_0000_0000' && response.request) {
            //     if (
            //         response.request.responseType === "json" &&
            //         response.request.responseText
            //     ) {
            //         response.data = JSON.parse(response.request.responseText);
            //     }
            // }
        }
        // console.log(response.data,'response.data');
        if(response.data.status && response.data.status!='000_0000_0000'){
            message.error(response.data.messages)
        }
        if(response.data.status == 401){
            localStorage.removeItem('token')
            window.location.href = window.location.origin + '/#/login'
        }

        return response.data;
    },
    err => {
        // loading.close()
        console.log(err,'err');
        loadingNum--;
        if (loadingNum < 1) {
            loadingNum = 0;
            setTimeout(() => {
                Loading.hide();
            })
        }

        if (String(err).indexOf('timeout') !== -1) {
            notification.open({
                title: '提示',
                message: '请求超时',
                type: 'error',
                duration: 3
            })
            return
        }
        if (err && err.response) {
            switch (err.response.status) {
            case 400:
                err.message = '请求错误'
                break

            case 401:
                if (noToken) {
                    noToken = false
                    message.error('未授权，请登录')
                    setTimeout(() => {
                        noToken = true
                    }, 3000)
                }
                localStorage.removeItem('token')
                window.location.href = window.location.origin + '/#/login'
                break

            case 403:
                err.message = '拒绝访问'
                break

            case 404:
                err.message = `请求地址出错: ${err.response.config.url}`
                break

            case 408:
                err.message = '请求超时'
                break

            case 500:
                err.message = '服务器内部错误'
                break

            case 501:
                err.message = '服务未实现'
                break

            case 502:
                err.message = '网关错误'
                break

            case 503:
                err.message = '服务不可用'
                break

            case 504:
                err.message = '网关超时'
                break

            case 505:
                err.message = 'HTTP版本不受支持'
                break
            default:
                err.message = `连接错误${err.response.status}`
            }

            // if (err.response.status != 401) {
            //     if(err.response?.data?.messages?.length) err.message =err.response.data.messages
            //     console.log(err.response.messages,'err.response.messages');
            //     notification.open({
            //         title: '提示',
            //         message: err.message,
            //         type: 'error',
            //         duration: 3
            //     })
            // }
        }
        return Promise.reject(err) // 返回接口返回的错误信息
    }
)

/**
 * 封装get方法
 * @param url
 * @param params
 * @param isMock 是否开启mock模拟数据
 * @param loading 是否显示遮罩加载
 * @returns {Promise}
 */


export function get (url, params, option) {
    let options = {
        isMock: false,
        loading: false,
        ...option
    };
    return axios({
        url: url,
        method: 'get',
        params,
        ...options
    })
}

/**
 * 封装post方法
 * @param url
 * @param params
 * @param isMock 是否开启mock模拟数据
 * @param loading 是否显示遮罩加载
 * @returns {Promise}
 */

export function post (url, data, option) {
    let options = {
        isMock: false,
        loading: false,
        ...option
    };
    return axios.post(url, data, options)
}
/**
 * 封装postUmd方法
 * @param url
 * @param params
 * @param isMock 是否开启mock模拟数据
 * @param loading 是否显示遮罩加载
 * @returns {Promise}
 */


export function postUmd (url, data, option) {
    let options = {
        isMock: false,
        loading: false,
        requestType: 'udm',
        ...option
    };
    // console.log('postUmd',options,333,data.json);
    if(Object.hasOwnProperty.call(options, 'formatter') && !options.formatter){
        // udmUpdateDat单独处理
        
    }else{
        let  $json = isJSON(data.json);
        if(data.json && $json){
            // 删除为'' 和没有值的字段
            // console.log(data.json,'data.json111',typeof(data.json));
            // let  $json = isJSON(data.json);
            Object.keys($json).forEach(item => {
                // if (!$json[item] && $json[item] !== 0) delete $json[item]
                if ($json[item]==='' || $json[item] === null) delete $json[item]
            })
            data.json = JSON.stringify($json);
            // console.log(data.json,'data.json222');

        }
    }
    let $data = handleData(data)
    // let $data = handleData(data);
    return axios.post(url, $data, options)
}
/*
 *postQuery 请求方法
 * @param url
 * @param params
 * @returns {Promise}
 */
export function postQuery (url, query, data, option) {
    let options = {
        isMock: false,
        loading: false,
        ...option
    };
    return axios({
        url: url,
        method: 'post',
        params: {
            ...query
        },
        data: data,
        ...options
    })
}

/*
 *put 请求方法
 * @param url
 * @param params
 * @returns {Promise}
 */
export function put (url, query, data, option) {
    let options = {
        isMock: false,
        loading: false,
        ...option
    };
    return axios({
        url: url,
        method: 'put',
        params: {
            ...query
        },
        data: data,
        ...options
    })
}

/*
 *del 请求方法
 * @param url
 * @query query
 */
export function del (url, query, data, option) {
    return axios.delete(url, {
        params: query
    })
}

/**
 * 封装ALL请求(合拼请求)
 * @param Array [请求1,请求2]
 * @returns {Promise}
 */

export function all (arr) {
    return axios.all([...arr])
}
